const XLSX = require('xlsx');
const Coupon = require('../models/Coupon');

class CouponExportService {
  constructor() {
    this.exportHeaders = [
      'coupon_id',
      'title',
      'description',
      'discount_type',
      'discount_value',
      'minimum_order_amount',
      'maximum_discount_amount',
      'validity_type',
      'valid_from',
      'valid_until',
      'validity_days',
      'usage_limit_per_user',
      'total_usage_limit',
      'total_used',
      'status',
      'remarks',
      'eligibility_rules',
      'inclusion_rules',
      'exclusion_rules',
      'time_windows',
      'created_at',
      'updated_at'
    ];
  }

  /**
   * 导出优惠券数据为Excel
   * @param {Object} filters - 过滤条件
   * @returns {Buffer} Excel文件缓冲区
   */
  async exportCoupons(filters = {}) {
    try {
      // 构建查询条件
      const queryConditions = this.buildQueryConditions(filters);
      
      // 获取优惠券数据
      const coupons = await Coupon.findAll(queryConditions);
      
      if (coupons.length === 0) {
        console.warn('没有找到符合条件的优惠券数据');
        return this.generateEmptyExport();
      }
      
      // 格式化数据
      const formattedData = this.formatCouponsForExport(coupons);
      
      // 生成Excel文件
      const buffer = this.generateExcelBuffer(formattedData, '优惠券数据');
      
      console.log(`成功导出${coupons.length}条优惠券数据`);
      return buffer;
    } catch (error) {
      console.error('导出优惠券数据失败:', error);
      throw error;
    }
  }

  /**
   * 构建查询条件
   * @param {Object} filters - 过滤条件
   * @returns {Object} 查询条件
   */
  buildQueryConditions(filters) {
    const where = {};
    
    // 状态过滤
    if (filters.status && filters.status !== 'all') {
      where.status = filters.status;
    }
    
    // 优惠类型过滤
    if (filters.discount_type && filters.discount_type !== 'all') {
      where.discount_type = filters.discount_type;
    }
    
    // 有效期类型过滤
    if (filters.validity_type && filters.validity_type !== 'all') {
      where.validity_type = filters.validity_type;
    }
    
    // 创建时间范围过滤
    if (filters.created_from || filters.created_to) {
      where.created_at = {};
      if (filters.created_from) {
        where.created_at.gte = new Date(filters.created_from);
      }
      if (filters.created_to) {
        where.created_at.lte = new Date(filters.created_to + ' 23:59:59');
      }
    }
    
    // 有效期范围过滤
    if (filters.valid_from) {
      where.valid_from = { gte: new Date(filters.valid_from) };
    }
    if (filters.valid_to) {
      where.valid_until = { lte: new Date(filters.valid_to + ' 23:59:59') };
    }
    
    // 标题搜索
    if (filters.title) {
      where.title = { like: `%${filters.title}%` };
    }
    
    const queryOptions = {
      where,
      order: [[filters.orderBy || 'created_at', filters.orderDirection || 'DESC']]
    };
    
    // 分页（如果需要）
    if (filters.limit) {
      queryOptions.limit = parseInt(filters.limit);
      queryOptions.offset = filters.offset ? parseInt(filters.offset) : 0;
    }
    
    return queryOptions;
  }

  /**
   * 格式化优惠券数据用于导出
   * @param {Array} coupons - 优惠券数据
   * @returns {Array} 格式化后的数据
   */
  formatCouponsForExport(coupons) {
    return coupons.map(coupon => {
      const formatted = {};
      
      // 基础字段
      formatted.coupon_id = coupon.coupon_id;
      formatted.title = coupon.title || '';
      formatted.description = coupon.description || '';
      formatted.discount_type = coupon.discount_type;
      formatted.discount_value = coupon.discount_value;
      formatted.minimum_order_amount = coupon.minimum_order_amount || 0;
      formatted.maximum_discount_amount = coupon.maximum_discount_amount || '';
      formatted.validity_type = coupon.validity_type;
      
      // 有效期字段
      formatted.valid_from = coupon.valid_from ? this.formatDate(coupon.valid_from) : '';
      formatted.valid_until = coupon.valid_until ? this.formatDate(coupon.valid_until) : '';
      formatted.validity_days = coupon.validity_days || '';
      
      // 使用限制字段
      formatted.usage_limit_per_user = coupon.usage_limit_per_user || '';
      formatted.total_usage_limit = coupon.total_usage_limit || '';
      formatted.total_used = coupon.total_used || 0;
      
      // 状态和备注
      formatted.status = coupon.status;
      formatted.remarks = coupon.remarks || '';
      
      // JSON规则字段（格式化为可读字符串）
      formatted.eligibility_rules = this.formatJsonField(coupon.eligibility_rules);
      formatted.inclusion_rules = this.formatJsonField(coupon.inclusion_rules);
      formatted.exclusion_rules = this.formatJsonField(coupon.exclusion_rules);
      formatted.time_windows = this.formatJsonField(coupon.time_windows);
      
      // 时间戳
      formatted.created_at = this.formatDateTime(coupon.created_at);
      formatted.updated_at = this.formatDateTime(coupon.updated_at);
      
      return formatted;
    });
  }

  /**
   * 生成Excel模板
   * @returns {Buffer} Excel模板文件缓冲区
   */
  generateTemplate() {
    try {
      const workbook = XLSX.utils.book_new();
      
      // 创建模板数据，包含示例行
      const templateData = [
        // 表头
        [
          '优惠券标题*',
          '描述',
          '优惠类型*',
          '优惠值*',
          '最低消费金额',
          '最高优惠金额',
          '有效期类型*',
          '有效期开始',
          '有效期结束',
          '有效天数',
          '每用户使用次数',
          '总使用次数限制',
          '状态',
          '备注',
          '资格规则',
          '包含规则',
          '排除规则',
          '时间窗口'
        ],
        // 示例1：金额券
        [
          '新用户注册礼券',
          '新用户专享优惠',
          'amount',
          '10',
          '50',
          '',
          'relative',
          '',
          '',
          '30',
          '1',
          '1000',
          'active',
          '仅限新用户',
          '{"member_level": "bronze"}',
          '{"categories": ["饮品"]}',
          '',
          ''
        ],
        // 示例2：折扣券
        [
          '会员专享8折券',
          '会员等级Silver及以上可用',
          'percent',
          '20',
          '100',
          '50',
          'absolute',
          '2024-01-01',
          '2024-12-31',
          '',
          '3',
          '',
          'active',
          '会员专享',
          '{"member_level": "silver"}',
          '',
          '{"items": ["酒水"]}',
          '{"weekdays": [1,2,3,4,5], "hours": "09:00-18:00"}'
        ],
        // 示例3：免费券
        [
          '生日免费饮品',
          '生日当月免费饮品一杯',
          'free',
          '0',
          '',
          '',
          'relative',
          '',
          '',
          '31',
          '1',
          '',
          'active',
          '生日专享',
          '{"birthday_month": true}',
          '{"categories": ["饮品"], "max_price": 15}',
          '{"categories": ["酒精饮品"]}',
          ''
        ]
      ];
      
      // 创建工作表
      const worksheet = XLSX.utils.aoa_to_sheet(templateData);
      
      // 设置列宽
      const colWidths = [
        { wch: 20 }, // 标题
        { wch: 25 }, // 描述
        { wch: 12 }, // 优惠类型
        { wch: 10 }, // 优惠值
        { wch: 15 }, // 最低消费
        { wch: 15 }, // 最高优惠
        { wch: 12 }, // 有效期类型
        { wch: 12 }, // 开始日期
        { wch: 12 }, // 结束日期
        { wch: 10 }, // 有效天数
        { wch: 15 }, // 用户使用次数
        { wch: 15 }, // 总使用次数
        { wch: 10 }, // 状态
        { wch: 20 }, // 备注
        { wch: 30 }, // 资格规则
        { wch: 30 }, // 包含规则
        { wch: 30 }, // 排除规则
        { wch: 30 }  // 时间窗口
      ];
      worksheet['!cols'] = colWidths;
      
      // 添加工作表到工作簿
      XLSX.utils.book_append_sheet(workbook, worksheet, '优惠券模板');
      
      // 生成Excel缓冲区
      const buffer = XLSX.write(workbook, { type: 'buffer', bookType: 'xlsx' });
      
      console.log('成功生成优惠券Excel模板');
      return buffer;
    } catch (error) {
      console.error('生成Excel模板失败:', error);
      throw error;
    }
  }

  /**
   * 生成统计报告
   * @returns {Buffer} 统计报告Excel文件缓冲区
   */
  async exportCouponStatistics() {
    try {
      const workbook = XLSX.utils.book_new();
      
      // 1. 概览统计
      const overviewStats = await this.getOverviewStatistics();
      const overviewWs = XLSX.utils.json_to_sheet(overviewStats);
      XLSX.utils.book_append_sheet(workbook, overviewWs, '概览统计');
      
      // 2. 按类型统计
      const typeStats = await this.getTypeStatistics();
      const typeWs = XLSX.utils.json_to_sheet(typeStats);
      XLSX.utils.book_append_sheet(workbook, typeWs, '按类型统计');
      
      // 3. 按状态统计
      const statusStats = await this.getStatusStatistics();
      const statusWs = XLSX.utils.json_to_sheet(statusStats);
      XLSX.utils.book_append_sheet(workbook, statusWs, '按状态统计');
      
      // 4. 使用情况统计
      const usageStats = await this.getUsageStatistics();
      const usageWs = XLSX.utils.json_to_sheet(usageStats);
      XLSX.utils.book_append_sheet(workbook, usageWs, '使用情况统计');
      
      const buffer = XLSX.write(workbook, { type: 'buffer', bookType: 'xlsx' });
      
      console.log('成功生成优惠券统计报告');
      return buffer;
    } catch (error) {
      console.error('生成统计报告失败:', error);
      throw error;
    }
  }

  /**
   * 获取概览统计
   */
  async getOverviewStatistics() {
    const totalCount = await Coupon.count();
    const activeCount = await Coupon.count({ where: { status: 'active' } });
    const expiredCount = await Coupon.count({ where: { status: 'expired' } });
    const draftCount = await Coupon.count({ where: { status: 'draft' } });
    
    return [
      { 指标: '总优惠券数', 数量: totalCount },
      { 指标: '活跃优惠券', 数量: activeCount },
      { 指标: '已过期优惠券', 数量: expiredCount },
      { 指标: '草稿优惠券', 数量: draftCount },
      { 指标: '活跃率', 数量: totalCount > 0 ? `${((activeCount / totalCount) * 100).toFixed(2)}%` : '0%' }
    ];
  }

  /**
   * 获取按类型统计
   */
  async getTypeStatistics() {
    const amountCount = await Coupon.count({ where: { discount_type: 'amount' } });
    const percentCount = await Coupon.count({ where: { discount_type: 'percent' } });
    const freeCount = await Coupon.count({ where: { discount_type: 'free' } });
    
    return [
      { 优惠类型: '金额券', 数量: amountCount },
      { 优惠类型: '折扣券', 数量: percentCount },
      { 优惠类型: '免费券', 数量: freeCount }
    ];
  }

  /**
   * 获取按状态统计
   */
  async getStatusStatistics() {
    const activeCount = await Coupon.count({ where: { status: 'active' } });
    const inactiveCount = await Coupon.count({ where: { status: 'inactive' } });
    const draftCount = await Coupon.count({ where: { status: 'draft' } });
    const expiredCount = await Coupon.count({ where: { status: 'expired' } });
    
    return [
      { 状态: '活跃', 数量: activeCount },
      { 状态: '非活跃', 数量: inactiveCount },
      { 状态: '草稿', 数量: draftCount },
      { 状态: '已过期', 数量: expiredCount }
    ];
  }

  /**
   * 获取使用情况统计
   */
  async getUsageStatistics() {
    // 这里需要根据实际的使用记录表来统计
    // 暂时返回模拟数据
    return [
      { 指标: '总使用次数', 数量: 0 },
      { 指标: '平均使用率', 数量: '0%' },
      { 指标: '最受欢迎优惠券', 数量: '暂无数据' }
    ];
  }

  /**
   * 生成空导出文件
   */
  generateEmptyExport() {
    const workbook = XLSX.utils.book_new();
    const worksheet = XLSX.utils.aoa_to_sheet([this.exportHeaders]);
    XLSX.utils.book_append_sheet(workbook, worksheet, '优惠券数据');
    return XLSX.write(workbook, { type: 'buffer', bookType: 'xlsx' });
  }

  /**
   * 生成Excel缓冲区
   */
  generateExcelBuffer(data, sheetName = '数据') {
    const workbook = XLSX.utils.book_new();
    const worksheet = XLSX.utils.json_to_sheet(data);
    
    // 设置列宽
    const colWidths = this.exportHeaders.map(header => {
      switch (header) {
        case 'title':
        case 'description':
          return { wch: 25 };
        case 'eligibility_rules':
        case 'inclusion_rules':
        case 'exclusion_rules':
        case 'time_windows':
          return { wch: 30 };
        case 'remarks':
          return { wch: 20 };
        default:
          return { wch: 15 };
      }
    });
    worksheet['!cols'] = colWidths;
    
    XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
    return XLSX.write(workbook, { type: 'buffer', bookType: 'xlsx' });
  }

  /**
   * 格式化日期
   */
  formatDate(date) {
    if (!date) return '';
    const d = new Date(date);
    return d.toISOString().split('T')[0];
  }

  /**
   * 格式化日期时间
   */
  formatDateTime(date) {
    if (!date) return '';
    const d = new Date(date);
    return d.toLocaleString('zh-CN', {
      year: 'numeric',
      month: '2-digit',
      day: '2-digit',
      hour: '2-digit',
      minute: '2-digit',
      second: '2-digit'
    });
  }

  /**
   * 格式化JSON字段
   */
  formatJsonField(jsonData) {
    if (!jsonData) return '';
    if (typeof jsonData === 'string') {
      try {
        JSON.parse(jsonData);
        return jsonData;
      } catch {
        return jsonData;
      }
    }
    return JSON.stringify(jsonData);
  }
}

module.exports = CouponExportService;